import pytest  # used for our unit tests
from codeflash.test import Solution

# unit tests

@pytest.fixture
def solution():
    return Solution()

# ----------------
# 1. Basic Test Cases
# ----------------

def test_single_vowel(solution):
    # Single vowel should remain unchanged
    codeflash_output = solution.reverseVowels("a") # 666ns -> 750ns (11.2% slower)
    codeflash_output = solution.reverseVowels("E") # 291ns -> 292ns (0.342% slower)

def test_single_consonant(solution):
    # Single consonant should remain unchanged
    codeflash_output = solution.reverseVowels("b") # 625ns -> 708ns (11.7% slower)
    codeflash_output = solution.reverseVowels("Z") # 292ns -> 292ns (0.000% faster)

def test_no_vowels(solution):
    # String with no vowels should remain unchanged
    codeflash_output = solution.reverseVowels("bcdfg") # 1.12μs -> 1.25μs (10.0% slower)
    codeflash_output = solution.reverseVowels("xyzXYZ") # 666ns -> 750ns (11.2% slower)

def test_all_vowels(solution):
    # All vowels should be reversed
    codeflash_output = solution.reverseVowels("aeiou") # 1.21μs -> 1.38μs (12.1% slower)
    codeflash_output = solution.reverseVowels("AEIOU") # 708ns -> 667ns (6.15% faster)

def test_mixed_case_vowels(solution):
    # Mixed case vowels should be reversed with case preserved
    codeflash_output = solution.reverseVowels("aEiOu") # 1.25μs -> 1.38μs (9.09% slower)

def test_mixed_vowels_and_consonants(solution):
    # Vowels should be reversed, consonants untouched
    codeflash_output = solution.reverseVowels("hello") # 1.33μs -> 1.54μs (13.5% slower)
    codeflash_output = solution.reverseVowels("leetcode") # 917ns -> 1.04μs (11.9% slower)
    codeflash_output = solution.reverseVowels("Programming") # 1.04μs -> 1.25μs (16.6% slower)

def test_palindrome_with_vowels(solution):
    # Palindrome with vowels, should remain palindrome if vowels reversed
    codeflash_output = solution.reverseVowels("madam") # 1.33μs -> 1.33μs (0.000% faster)
    codeflash_output = solution.reverseVowels("racecar") # 917ns -> 959ns (4.38% slower)

# ----------------
# 2. Edge Test Cases
# ----------------

def test_empty_string(solution):
    # Empty string should return empty string
    codeflash_output = solution.reverseVowels("") # 584ns -> 708ns (17.5% slower)

def test_only_vowels(solution):
    # Only vowels, should be reversed
    codeflash_output = solution.reverseVowels("aeiouAEIOU") # 1.79μs -> 1.83μs (2.24% slower)

def test_repeated_vowels(solution):
    # Repeated vowels, should be reversed
    codeflash_output = solution.reverseVowels("aaaa") # 1.25μs -> 1.38μs (9.09% slower)
    codeflash_output = solution.reverseVowels("eeeee") # 583ns -> 625ns (6.72% slower)

def test_vowels_at_ends(solution):
    # Vowels at both ends should swap
    codeflash_output = solution.reverseVowels("abecidofu") # 1.67μs -> 1.83μs (9.11% slower)

def test_no_letters(solution):
    # String with digits and symbols, no vowels
    codeflash_output = solution.reverseVowels("12345!@#") # 1.25μs -> 1.38μs (9.09% slower)

def test_vowels_and_nonletters(solution):
    # Vowels and non-letters, only vowels should be reversed
    codeflash_output = solution.reverseVowels("a1e2i3o4u") # 1.62μs -> 1.79μs (9.32% slower)

def test_unicode_non_ascii(solution):
    # Non-ASCII characters, only ASCII vowels should be reversed
    codeflash_output = solution.reverseVowels("héllö wörld") # 1.54μs -> 1.62μs (5.11% slower)

def test_adjacent_vowels(solution):
    # Adjacent vowels should be reversed in place
    codeflash_output = solution.reverseVowels("aaee") # 1.25μs -> 1.38μs (9.09% slower)
    codeflash_output = solution.reverseVowels("aeae") # 584ns -> 666ns (12.3% slower)

def test_vowels_with_spaces(solution):
    # Vowels separated by spaces
    codeflash_output = solution.reverseVowels("a e i o u") # 1.62μs -> 1.79μs (9.32% slower)

def test_vowels_with_punctuation(solution):
    # Vowels with punctuation
    codeflash_output = solution.reverseVowels("a,e.i!o?u") # 1.67μs -> 1.75μs (4.80% slower)

def test_case_sensitivity(solution):
    # Case should be preserved when reversing
    codeflash_output = solution.reverseVowels("AbEcIdOfU") # 1.71μs -> 1.83μs (6.76% slower)

def test_same_vowel(solution):
    # All same vowel, should remain the same
    codeflash_output = solution.reverseVowels("iiii") # 1.25μs -> 1.38μs (9.09% slower)

def test_string_with_y(solution):
    # 'y' is not a vowel in this context
    codeflash_output = solution.reverseVowels("yoyo") # 1.21μs -> 1.29μs (6.50% slower)

def test_string_with_upper_and_lower(solution):
    # Mix of upper and lower vowels
    codeflash_output = solution.reverseVowels("aEIoU") # 1.33μs -> 1.33μs (0.075% faster)

def test_long_string_no_vowels(solution):
    # Long string, no vowels
    s = "b" * 1000
    codeflash_output = solution.reverseVowels(s) # 46.5μs -> 36.1μs (29.0% faster)

# ----------------
# 3. Large Scale Test Cases
# ----------------

def test_large_string_all_vowels(solution):
    # Large string of only vowels
    s = "aeiou" * 200  # 1000 characters
    expected = ("uoiea" * 200)[::-1]  # reverse the string
    # Actually, reverse all vowels: so the string is all vowels, so just reverse the string
    expected = s[::-1]
    codeflash_output = solution.reverseVowels(s) # 53.7μs -> 52.8μs (1.58% faster)

def test_large_string_mixed(solution):
    # Large string with vowels and consonants
    s = ("abcde" * 200)  # 1000 characters, vowels at positions 0 and 4 in each block
    # Find all vowels in s, reverse them, and put them back
    vowels = [c for c in s if c in Solution._vowels]
    expected_chars = []
    vowel_idx = len(vowels) - 1
    for c in s:
        if c in Solution._vowels:
            expected_chars.append(vowels[vowel_idx])
            vowel_idx -= 1
        else:
            expected_chars.append(c)
    expected = ''.join(expected_chars)
    codeflash_output = solution.reverseVowels(s)

def test_large_string_no_vowels(solution):
    # Large string with no vowels
    s = "bcdfg" * 200  # 1000 characters
    codeflash_output = solution.reverseVowels(s) # 47.3μs -> 35.8μs (32.0% faster)

def test_large_string_vowels_at_edges(solution):
    # Large string, vowels only at the very start and end
    s = "a" + "b" * 998 + "e"
    expected = "e" + "b" * 998 + "a"
    codeflash_output = solution.reverseVowels(s) # 46.5μs -> 36.0μs (29.4% faster)

def test_large_string_vowels_and_digits(solution):
    # Large string with digits and vowels
    s = ("a1e2i3o4u5" * 90)[:1000]  # up to 1000 chars
    vowels = [c for c in s if c in Solution._vowels]
    expected_chars = []
    vowel_idx = len(vowels) - 1
    for c in s:
        if c in Solution._vowels:
            expected_chars.append(vowels[vowel_idx])
            vowel_idx -= 1
        else:
            expected_chars.append(c)
    expected = ''.join(expected_chars)
    codeflash_output = solution.reverseVowels(s)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import pytest  # used for our unit tests
from codeflash.test import Solution

# unit tests

@pytest.fixture
def sol():
    # Fixture to instantiate Solution for reuse
    return Solution()


# 1. Basic Test Cases

def test_basic_single_vowel(sol):
    # Single vowel - should remain unchanged
    codeflash_output = sol.reverseVowels("a") # 625ns -> 750ns (16.7% slower)
    codeflash_output = sol.reverseVowels("E") # 292ns -> 292ns (0.000% faster)

def test_basic_no_vowels(sol):
    # No vowels - should remain unchanged
    codeflash_output = sol.reverseVowels("bcdfg") # 1.12μs -> 1.21μs (6.87% slower)
    codeflash_output = sol.reverseVowels("xyz") # 459ns -> 542ns (15.3% slower)

def test_basic_all_vowels(sol):
    # All vowels - should be reversed
    codeflash_output = sol.reverseVowels("aeiou") # 1.17μs -> 1.33μs (12.5% slower)
    codeflash_output = sol.reverseVowels("AEIOU") # 708ns -> 666ns (6.31% faster)

def test_basic_mixed_case(sol):
    # Mixed case vowels
    codeflash_output = sol.reverseVowels("hEllO") # 1.29μs -> 1.54μs (16.2% slower)
    codeflash_output = sol.reverseVowels("LeetCode") # 1.00μs -> 1.04μs (3.94% slower)

def test_basic_vowels_at_ends(sol):
    # Vowels at both ends
    codeflash_output = sol.reverseVowels("abecidofu") # 1.62μs -> 1.79μs (9.32% slower)

def test_basic_vowels_and_consonants(sol):
    # Vowels interleaved with consonants
    codeflash_output = sol.reverseVowels("hello world") # 1.96μs -> 2.00μs (2.05% slower)

def test_basic_repeated_vowels(sol):
    # Repeated vowels
    codeflash_output = sol.reverseVowels("aabbccEE") # 1.58μs -> 1.71μs (7.32% slower)

def test_basic_vowels_and_spaces(sol):
    # Vowels with spaces
    codeflash_output = sol.reverseVowels("a e i o u") # 1.62μs -> 1.79μs (9.27% slower)


# 2. Edge Test Cases

def test_edge_empty_string(sol):
    # Empty string
    codeflash_output = sol.reverseVowels("") # 584ns -> 708ns (17.5% slower)

def test_edge_one_char_non_vowel(sol):
    # Single non-vowel character
    codeflash_output = sol.reverseVowels("b") # 584ns -> 708ns (17.5% slower)

def test_edge_all_same_vowel(sol):
    # All same vowel
    codeflash_output = sol.reverseVowels("aaaaa") # 1.17μs -> 1.33μs (12.5% slower)
    codeflash_output = sol.reverseVowels("UUUUU") # 750ns -> 625ns (20.0% faster)

def test_edge_palindrome_vowels(sol):
    # Palindrome with vowels
    codeflash_output = sol.reverseVowels("racecar") # 1.50μs -> 1.58μs (5.30% slower)

def test_edge_vowel_and_nonvowel_swap(sol):
    # Vowels at start and end, non-vowels in the middle
    codeflash_output = sol.reverseVowels("aBCdeE") # 1.42μs -> 1.46μs (2.95% slower)

def test_edge_special_characters(sol):
    # Special characters and digits
    codeflash_output = sol.reverseVowels("!a2e#i$o%u^") # 1.88μs -> 1.83μs (2.29% faster)

def test_edge_unicode_vowels(sol):
    # Unicode characters that are not vowels should not be treated as vowels
    codeflash_output = sol.reverseVowels("hëllo") # 1.17μs -> 1.33μs (12.5% slower)

def test_edge_vowels_next_to_each_other(sol):
    # Consecutive vowels
    codeflash_output = sol.reverseVowels("queue") # 1.42μs -> 1.50μs (5.60% slower)
    codeflash_output = sol.reverseVowels("ae") # 500ns -> 542ns (7.75% slower)

def test_edge_vowels_only_at_edges(sol):
    # Vowels only at the start and end
    codeflash_output = sol.reverseVowels("ab") # 917ns -> 1.12μs (18.5% slower)
    codeflash_output = sol.reverseVowels("ub") # 417ns -> 500ns (16.6% slower)

def test_edge_non_ascii_letters(sol):
    # Non-ASCII letters, should not be treated as vowels
    codeflash_output = sol.reverseVowels("hëllö") # 1.12μs -> 1.25μs (10.0% slower)
    codeflash_output = sol.reverseVowels("façade") # 1.04μs -> 1.12μs (7.38% slower)

def test_edge_case_sensitivity(sol):
    # Ensure that case is respected
    codeflash_output = sol.reverseVowels("aEiOu") # 1.33μs -> 1.38μs (3.05% slower)
    codeflash_output = sol.reverseVowels("AbCdEf") # 875ns -> 1.04μs (16.0% slower)

def test_edge_vowels_with_numbers(sol):
    # Vowels and numbers
    codeflash_output = sol.reverseVowels("a1e2i3o4u5") # 1.79μs -> 1.88μs (4.48% slower)

def test_edge_only_vowels_and_spaces(sol):
    # Only vowels and spaces
    codeflash_output = sol.reverseVowels("a e i o u") # 1.58μs -> 1.79μs (11.6% slower)

def test_edge_long_repeated_pattern(sol):
    # Repeated pattern, check for correct reversal
    codeflash_output = sol.reverseVowels("abecidofuabecidofu") # 2.42μs -> 2.33μs (3.56% faster)

# 3. Large Scale Test Cases

def test_large_no_vowels(sol):
    # Large string with no vowels
    s = "b" * 1000
    codeflash_output = sol.reverseVowels(s) # 46.4μs -> 36.2μs (28.2% faster)

def test_large_all_vowels(sol):
    # Large string of only vowels
    s = "aeiou" * 200  # 1000 characters
    expected = s[::-1]
    codeflash_output = sol.reverseVowels(s) # 53.6μs -> 52.8μs (1.42% faster)

def test_large_mixed_vowels_and_consonants(sol):
    # Large string with vowels at every even index
    base = []
    for i in range(1000):
        if i % 2 == 0:
            base.append("a")
        else:
            base.append("b")
    s = "".join(base)
    # After reversal, all 'a's should be in reverse order, but 'b's stay in place
    vowels = [c for c in s if c in Solution._vowels]
    expected = list(s)
    vi = len(vowels) - 1
    for i in range(len(s)):
        if s[i] in Solution._vowels:
            expected[i] = vowels[vi]
            vi -= 1
    codeflash_output = sol.reverseVowels(s)

def test_large_vowels_at_edges(sol):
    # Vowels only at the edges of a large string
    s = "a" + "b" * 998 + "e"
    codeflash_output = sol.reverseVowels(s) # 47.6μs -> 38.3μs (24.4% faster)

def test_large_random_pattern(sol):
    # Large string with a random pattern of vowels and consonants
    pattern = ("abcde" * 200)  # 1000 characters
    # Find all vowels in the string
    vowels = [c for c in pattern if c in Solution._vowels]
    expected = list(pattern)
    vi = len(vowels) - 1
    for i in range(len(pattern)):
        if pattern[i] in Solution._vowels:
            expected[i] = vowels[vi]
            vi -= 1
    codeflash_output = sol.reverseVowels(pattern)

def test_large_all_uppercase_vowels(sol):
    # Large string with only uppercase vowels
    s = "AEIOU" * 200
    expected = s[::-1]
    codeflash_output = sol.reverseVowels(s) # 54.2μs -> 56.3μs (3.85% slower)

def test_large_alternating_case_vowels(sol):
    # Large string with alternating case vowels
    s = ("aEiOu" * 200)
    expected = s[::-1]
    codeflash_output = sol.reverseVowels(s) # 57.7μs -> 55.9μs (3.13% faster)

def test_large_vowels_and_digits(sol):
    # Large string with vowels and digits
    s = ("a1e2i3o4u5" * 100)
    vowels = [c for c in s if c in Solution._vowels]
    expected = list(s)
    vi = len(vowels) - 1
    for i in range(len(s)):
        if s[i] in Solution._vowels:
            expected[i] = vowels[vi]
            vi -= 1
    codeflash_output = sol.reverseVowels(s)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from codeflash.test import Solution

def test_Solution_reverseVowels():
    Solution.reverseVowels(Solution(), 'Aip')

def test_Solution_reverseVowels_2():
    Solution.reverseVowels(Solution(), '\x00\x00')